Shareware Grab Bag

home *** CD-ROM | disk | FTP | other *** search

/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / future86.arc / DEMO.TXT next >

Wrap

Text File | 1987-04-01 | 21.1 KB | 625 lines

FUTURE86 tm ...The language Unique in all the World... From... DEVELOPMENT ASSOCIATES 1520 S Lyon Santa Ana, CA 92705 (714) 835 9512 Compuserve 71460,1146 Copyright (C) 1987 by Development Associates and RIGY Corporation All rights reserved This FUTURE86 demonstration diskette is an actual application example. This diskette contains several files: DRIVER.FIF....source file for the demo program DRIVER.COM....execution or runtime file for the demo produced by the FUTURE86 compiler, FUT86.COM DRIVER.LST....listing file produced via the compiler DRIVER.SYM....Symbol file produced by the compiler DRIVER.ERR....Error file produced by the compiler (this file is empty...because there are no errors) DEMO.TXT....the actual text you are now viewing comes from this file SCRIPT.SCR....This is an output control file that contains coded character strings that control the formatting, attributes, placement, speed and other parameters of the text you are now viewing. This demonstration program furnishes information about FUTURE86 using actual FUTURE86 generated code. Further, you can look at the source code and listings, observe the code compactness and see the many advantages that FUTURE86 offers you. Welcome to FUTURE86 the world class programming environment that truly belongs to the future... FUTURE86 runs under MS\DOS, on IBM PC,AT or compatibles and generates compact executable object programs and highly readable compilation lists with a minimum of programming effort. FUTURE86 is a variable level language that compiles directly to machine code. The language is inherently rommable, reentrant and recursive. Unique among existing languages, you may freely mix assembly language and high level statements within procedures. FUTURE86 is an "environment natural" language. You are free to choose procedure names that relate to your application needs. Additionally, FUTURE86 is extensible, allowing you to extend the language into one that is application specific. FUTURE86 program listings produce highly readable code both at high and low levels. This is especially valuable when debugging real time control applications. Writing programs in FUTURE86 is intuitively much easier than with other languages because its syntax is so simple, consisting of just tokens and spaces. FUTURE86 compilation is almost trivial. You can concentrate on developing your algorithms instead of being involved in detailed syntax requirements. FUTURE86's fast, two pass compiler, inherently supports: ** structured programs ** forward referencing ** XENIX-like file access ** MS\DOS INT processes ** software and 8087 floating point ** application romming ** arrays ** .COM or .HEX files ** interrupt driven architectures. ** conditional compilation and linkage ** "include" files ** 8086/88 and 80186/8 instructions. ** high level listings that detail the object level ** high level direct register access Full support is provided for local and global labels and named procedures. In addition to increasing code readability, this feature allows full symbolic debugging. An important part of the FUTURE86 environment is the integrated, variable level debugging module, FDT86. This module allows debugging at either machine or high levels in a symbolic, interactive way. FUTURE86 generated code is fast making it suitable for real time control applications. It is also ideal for applications such as AI, CASE, expert systems, business, engineering analysis, modeling, etc.. FUTURE86 has the following inherent properties: * Naturally "structured" * Debugging resources integrated into programming environment. * Produces compact code. * Extensible. You actually enlarge the language for your application. * Run time or size optimizing is completely under your control * Write code at either an arbitrarily abstract high level or in assembly language within the same procedure depending on your needs with no complex context switching. High and low level expressions can be freely mixed. * FUTURE86 is fast. No runtime interpreters like BASIC, FORTH or LISP. ***Its easy to see why FUTURE86 obsoletes other programming languages*** Anyone can learn FUTURE86 quickly because of its remarkably simple and logical concepts. FUTURE86 is a mature World Class language with thousands of users, hard at work in many diverse applications... and it is still being extended... In addition to a complete set of low level assembler instructions and compiler directives, FUTURE86 supplies hundreds of powerful, natural language, extensible, high level procedures that give you programming power unmatched by other languages. FUTURE86 puts you in command! You can customize FUTURE86 to minimize the size of your application's .COM files and make MS\DOS environment independent applications such as ROM/RAM based systems. You can also extend FUTURE86. FUTURE86 will revise your thinking about what constitutes a modern programming language. Instead of a complex, difficult to understand language, FUTURE86 is elegantly simple. Programs in FUTURE86 are expressed as a collection of tokens, each of which represent a procedure that the computer sequentially executes. These tokens can be referred to as "words" and they include the hundreds supplied with FUTURE86 and the ones you will create in writing your program or application. A FUTURE86 word is written as follows: : NAME processa porcessb processc .... ; The colon starts a word definition. NAME is the name of the procedure such as BANANA, GORILLA, SORT, etc. You can choose names that relate to your needs. Processa, processb, etc.. are the names of previously defined (although FUTURE86 allows forward referencing ) FUTURE86 words that are to be sequentially executed. The last portion of the definition is the semicolon which signals the compiler that the definition is now complete. FUTURE86 source files have a .FIF extension which is symbolic for "FUTURE INFORMATION FILE". Your source program can be this simple: : SEE_COUNT 10 DO I 48 + CO LOOP ; END SEE_COUNT<cr> After this source program has been compiled by the FUTURE86 compiler, and the resulting .COM file executed, the screen will display: 0123456789 and then return to the MS\DOS prompt. The compilation procedure used is: FUT86 COUNT KERNEL Where FUT86 is the FUTURE86 compiler, COUNT is our program's name and KERNEL is the file that contains the high level FUTURE86 words that we are referencing in our program. Let us now explore the details of the source program. First, we have the definition itself that starts with a colon to signal the compiler that we are now defining a high level procedure. Then, the name of the procedure, SEE_COUNT (we are free to use any names for procedures) is placed and is followed by the procedures which are: 10---number of times (decimal) we wish the loop construct to execute. DO---start of the loop construct I---places the loop index or the loop count value on the top of the data stack. 48--number 48 (decimal) is placed on top of the data stack. This is used to convert the loop number to an ASCII value suitable for outputing to the screen. +---top two numbers on the data stack are added together to form the desired ASCII digits value. Note: this is RPN notation. FUTURE86 generally employs this type of number manipulation. CO--top of data stack value (an ASCII value) is sent to the output device. This procedure means "console out". LOOP--end statement of the loop construct. The procedure exits this point after reaching a loop count of one less than the loop index (the 10). The count therefore starts at 0. ;---signal to the compiler that we have now completed our high level FUTURE86 definition. END is a required statement at the conclusion of every FUTURE86 source file. FUTURE86 provides you with a set of basic tools (procedures) and its compiler has the important responsibility of correctly compiling your source programs that are built with these tools. FUTURE86 also has the responsibility of providing you with a complete and powerful debugging resource that allows you to completely debug your algorithms. Because FUTURE86 source syntax is so simple, compilation is almost a trivial matter. This is usually a major problem in most other languages. FUTURE86 language syntax and internal structure encourage program modularization. Achieving structured programs is straightforward without being restrictive and eliminates the "GOTO" concept that can make program reading and maintenance so difficult. This is an important characteristic of a powerful programming language. FUTURE86 contains a rich set of string procedures. FUTURE86 exploits a concept of string parameters that is unique to FUTURE86 and is not found in other languages. This will make your programs much more powerful. This short core dump program should give you some insite as to the simplicity and power that FUTURE86 can give you. : DUMP_1LINE \address, count --- outputline OVER SWAW PRW \display line seg. addr ':' CO \output colon OVER PRW 2 SPACES \output 2 spaces BEGIN CGET PRB \get 1 byte and output it in hex SPACE \output a space ?NULL \is string access finished? UNTIL \go back to BEGIN till finished CRLF ; \output a cr and lf : DUMP \address, count --- outputrange BEGIN 16 SSPLIT \get 16 bytes from memory DUMP_1LINE \output one line of data ?NULL \are we done? UNTIL ; Labels are an important FUTURE86 resource. Labeled procedure names, when properly selected, convey information about the procedure that the label references. The use of labels in your source code enable symbolic debugging. FUTURE86 produces highly readable compilation listings that are tightly coupled to the machine level. You can read the high level coding with its abstract and application oriented syntax for maximum comprehension and at the same time the code generated can be tracked down to its actual byte level roots. Lets see what the following code example produces. ESCAPE EQU 1BH : PRINTMODE ESCAPE 2 DO LO LOOP ; When this source code is compiled the listing becomes: 1B80/ : PRINTMODE 1B80/E8A3E5 1B ESCAPE 1B84/E89FE5 02 2 1B88/E82AE6 DO 1B8B/E8CBF5 LO 1B8E/E833E6 E9F7FF LOOP 1B94/C3 ; If this code is carefully disassembled, we will see something like: 1B80 E8A3E5 CALL 0126 \CONSTANT PROCEDURE 1B83 1B \ASCII CONSTANT--ESCAPE 1B84 E89FE5 CALL 0126 \CALL CONSTANT PROCEDURE AGAIN 1B87 02 \THE CONSTANT 1B88 E82AE6 CALL 01B5 \CALL THE DO PROCEDURE 1B8B E8CBF5 CALL 1159 \CALL THE LO PROCEDURE 1B8E E833E6 CALL 01C4 \CALL THE LOOP PROCEDURE 1B91 E9F7FF JMP 1B8B \IF MORE LOOPS REQUIRED JMP BACK 1B94 C3 RET \PROCEDURE IS FINISHED--RETURN As you can see, most FUTURE86 high level words function as machine code subroutines. The expansion of a FUTURE86 procedure can be viewed as a series of CALL instructions to other defined procedures. Simplicity is elegance. FUTURE86 provides complete flow control procedures including: IF(-IF)..ELSE..THEN BEGIN..UNTIL CASE..ENDCASE SELECT..ENDSELECT BEGIN..IF(-IF)..REPEAT DO..LOOP BEGIN..BREAK..UNTIL BEGIN...AGAIN The FUTURE86 assembler can be used to generate named procedures in a manner similar to high level FUTURE86. For example, THE FUTURE86 procedure, ROT, that rotates the third stack element to the top of the data stack is written completely in assembler as follows: : ROT \LOW WORD\ LDS AX,[BP] XCHG AX,[BP + 4] XCHG AX,[BP + 8] MOV [BP],AX \HI WORD\ MOV AX,DS XCHG AX,[BP + 6] XCHG AX,[BP + 10] MOV [BP + 2],AX ; Writing in FUTURE86 assembly language is almost exactly the same as writing in high level FUTURE86. In fact, you can directly intermix assembly language and high level FUTURE86 within the same procedure with no restrictions. :MIXED \MIXED HIGH/LOW LEVEL PROCEDURES MOV AH,3 \OPERATION TYPE MOV BH,BYTE CS:PAGE# \SELECT PAGE NO. IVDOS \VIDEO BIOS--HIGH LEVEL CMP DH,23 \ROW LIMIT? JL _OUTPUT \COND. JMP TO LOCAL LABEL SCROLL_UP_ONE_LINE \HI-LEVEL SCROLL 22 0 PUT_CURS \ADJ CURS POS _OUTPUT: WRITE_ATR \PUT CHAR ATTR CO ; \WRITE THE CHAR AND END FUTURE86 has complete provision for macros. CODEMACRO macroname assembly statement assembly statement | | | assembly statement ENDM FUTURE86 provides for decimal, binary, and hex number bases and for character and character string constants. FUTURE86 provides a simple mechanism for conditional compilation of source programs via use of the word [CC : [CC formula ..FUTURE86 routine CC] FUTURE86 code is very readable. For example, the following sequence: START 3 TURN_RIGHT PICK STOP relates to the driving program for a robotic application and expresses the starting motion, turning clock-wise by three steps, pick up an item and then stop. A natural syntax for FUTURE86. The FUTURE86 debugger (FDT86) provides an interactive debugger for testing your FUTURE86 programs in a fast, efficient manner. FDT86 is also very useful for program prototyping and as a FUTURE86 learning environment. FDT86 has a complete symbolic, interactive environment to give you the power you need. You can execute any words that are resident, set and execute breakpoints, investigate procedure stack behavior, define and execute new FUTURE86 words and perform other useful debugging tasks such as examine ports, memory, etc.. These FDT86 commands are available: A -- Change map/set arguments C -- Call subroutine D -- Dump memory E -- Erase FDT generated definitions F -- Fill/FUTURE mode G -- Go execute user program H -- 16 bit add/subtract L -- reList FDT generated definitions M -- Move memory block O -- Set origin address P -- Display parameter stack Q -- Quit QC -- Quit and stay resident R -- Read file S -- Change memory (byte) U -- Upload program/data/source code V -- Display label value W -- Change memory (word) X -- Change register Z -- Display program position information .. -- retain data stack info da-- down arrow. Repeat last command. _ -- set break point at addr or label Other -- Any available high level FUTURE86 procedures. The FDT86 environment is also excellent for developing simple utility words or procedures since you can easily save your work, in the form of source code. The ability to execute virtually any FUTURE86 words from within FDT86 in an immediate environment is very powerful. Additionally, the high level breakpoint resources allow you to really focus on performance details of any portion of your program. Executing and debugging your application code that was compiled with the FUTURE86 compiler FDT86 offers powerful debugging resources, both at high and low levels. This capability will really help you successfully debug your applications in an efficient manner. More than 250 pages of documentation are furnished with FUTURE86 which includes a detailed description of the language, programming techniques, and complete procedure glossaries that enable you to quickly learn and become proficient at writing successful programs. The manual includes the following sections: PART I...FUTURE86 RESOURCES, LANGUAGE AND COMPILER INTRODUCTION FUTURE86 ADVANTAGES FUTURE86 RESOURCES FUTURE86 COMPILER/ASSEMBLER (FUT86) FUTURE86 DEBUGGER (FDT86) OTHER FILES THE FIRST THING TO DO MAKING WORKING SYSTEM FILES RAM DISK OPERATION STARTING FUTURE86 FUTURE86 COMPILER COMPILER MESSAGES COMPILER ERROR MESSAGES KERNEL COMPILATION PROGRAM EXECUTION EXAMPLE FUTURE86, THE LANGUAGE LIST FILE PRINTING D CHARTS-STRUCTURED FLOW CHARTS PROGRAM WRITING STYLE FUTURE86 STRING PROCESSING LABELS LINKAGE MECHANISM REVERSE POLISH NOTATION AND STACKS DATA STACK RETURN STACK OBJECT READABILITY STACK PROCESSING BRANCHING--FLOW CONTROL ARRAYS SOURCE PROGRAM STRUCTURE PSEUDO INSTRUCTIONS FUTURE86 ASSEMBLER STRUCTURE MIXING ASSEMBLER AND HIGH LEVEL CODE MACROS EXAMPLES WHEN TO USE ASSEMBLY PROCEDURES FUTURE86 NUMBER PROCESSING CHARACTER CONSTANTS CHARACTER STRING CONSTANTS SPECIAL CHARACTER CONSTANT RESOURCE PROGRAM AND DATA LOCATIONS COMPUTATION SEQUENCE--ASSEMBLER COMPUTATION SEQUENCE--HIGH LEVEL FUTURE86 ROM APPLICATIONS CONDITIONAL COMPILATION SOURCE READABILITY AND CODING STYLE PROCEDURE NAME ALIASING DIRECT REGISTER ACCESS WORDS PART II...FDT86--FUTURE86 DEBUGGER FDT86 DEBUGGER ASSEMBLER MODE COMMANDS FUTURE MODE DEBUG ENVIRONMENT FDT HIGH LEVEL BREAKPOINTS FDT ALIASING PROPERTIES FDT ERROR MESSAGES USING FDT FOR YOUR PROGRAM DEVELOPMENT PART III...FUTURE86 GLOSSARY PART IV...SYSTEM GLOSSARY APPENDICES FUTURE86 QUICK REFERENCE GUIDE A complete FUTURE86 environment consists of the compiler, kernel library, FDT86, a text editor, specialized printing utility and various demo and utility files. Documentation consists of a comprehensive tutorial style manual complete with procedure glossaries. Optional libraries available include: Software and 8087 floating point, RS-232, Modem and GENHEX, a .COM to Intel Hex file converter. This demonstration can only give you a brief sense of the power that awaits you within FUTURE86... Thank you for using this demo... If you are serious about software development shouldn't you be using FUTURE86 ? FUTURE86 is a fully supported professional language intended for serious applications. To order or for additional information write or call: DEVELOPMENT ASSOCIATES 1520 S Lyon Santa Ana, CA. 92705 USA (714) 835 9512 Do it today....and brighten your future!